package pe.com.cotelasa.scp.controlador;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;

import javax.faces.event.ActionEvent;
import javax.inject.Inject;
import javax.inject.Named;

import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFPicture;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.Picture;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.util.IOUtils;
import org.primefaces.event.DateSelectEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;

import pe.com.cotelasa.common.controlador.MBGenerico;
import pe.com.cotelasa.scp.common.IObserver;
import pe.com.cotelasa.scp.controlador.backingBean.BKDetalleOrdenCompraServicio;
import pe.com.cotelasa.scp.controlador.backingBean.BKOrdenServicio;
import pe.com.cotelasa.scp.controlador.backingBean.BKPartidaDespacho;
import pe.com.cotelasa.scp.controlador.comando.ComandoActualizar;
import pe.com.cotelasa.scp.controlador.comando.ComandoGuardar;
import pe.com.cotelasa.scp.controlador.comando.ComandoVer;
import pe.com.cotelasa.scp.controlador.comando.IComando;
import pe.com.cotelasa.scp.dominio.common.Constantes;
import pe.com.cotelasa.scp.dominio.service.IServicioDetalleOrdenCompraServicio;
import pe.com.cotelasa.scp.dominio.service.IServicioOrdenCompraServicio;
import pe.com.cotelasa.scp.dominio.service.IServicioOrdenPedido;
import pe.com.cotelasa.scp.dominio.service.IServicioTipoMoneda;
import pe.com.cotelasa.scp.dominio.service.IServicioCategoriaArticulo;
import pe.com.cotelasa.scp.dominio.service.IServicioProveedor;
import pe.com.cotelasa.scp.dominio.service.IServicioSede;
import pe.com.cotelasa.scp.dominio.service.IServicioContacto;
import pe.com.cotelasa.scp.dominio.service.IServicioCorrelativoDocumento;
import pe.com.cotelasa.scp.dominio.service.IServicioTipoDocumento;
import pe.com.cotelasa.scp.dominio.common.ESTADO_REGISTRO;
import pe.com.cotelasa.scp.dominio.common.URLPaginacion;
import pe.com.cotelasa.scp.dominio.excepcion.ServiceException;
import pe.com.cotelasa.scp.dominio.common.util.UtilitarioFecha;
import pe.com.cotelasa.scp.dominio.service.IServicioArticulo;
import pe.com.cotelasa.scp.dominio.service.IServicioComposicionArticulo;
import pe.com.cotelasa.scp.dominio.service.IServicioIgv;
import pe.com.cotelasa.scp.dominio.service.IServicioParametro;
import pe.com.cotelasa.scp.dominio.service.IServicioServicio;
//import pe.com.cotelasa.scp.dominio.service.IServicioProveedorServicio;
import pe.com.cotelasa.scp.dominio.service.IServicioTipoFormaPago;
import pe.com.cotelasa.scp.entidad.Articulo;
import pe.com.cotelasa.scp.entidad.CategoriaArticulo;
import pe.com.cotelasa.scp.entidad.ComposicionArticulo;
import pe.com.cotelasa.scp.entidad.Contacto;
import pe.com.cotelasa.scp.entidad.CorrelativoDocumento;
import pe.com.cotelasa.scp.entidad.Sede;
import pe.com.cotelasa.scp.entidad.DetalleOrdenCompraServicio;
import pe.com.cotelasa.scp.entidad.DetallePedidoOp;
import pe.com.cotelasa.scp.entidad.OrdenCompraServicio;
import pe.com.cotelasa.scp.entidad.OrdenPedido;
import pe.com.cotelasa.scp.entidad.ParametroDetalle;
import pe.com.cotelasa.scp.entidad.PartidaDespacho;
import pe.com.cotelasa.scp.entidad.Proveedor;
//import pe.com.cotelasa.scp.entidad.ProveedorServicio;
import pe.com.cotelasa.scp.entidad.Servicio;
import pe.com.cotelasa.scp.entidad.TipoDocumento;
import pe.com.cotelasa.scp.entidad.TipoMoneda;
import pe.com.cotelasa.seguridad.controlador.backingBean.BKSession;

/**
 * @author usuario
 */
@Named(value = "MBOrdenServicio")
@Scope("request")
public class MBOrdenServicio extends MBGenerico implements IMantenedor, IObserver, Serializable {

    private static final long serialVersionUID = -3008828663507135743L;
    private static Logger logger = Logger.getLogger(MBOrdenServicio.class);
    @Inject
    private BKOrdenServicio bkOrdenServicio;
    @Inject
    private BKPartidaDespacho bkPartidaDespacho;
    @Inject
    private IServicioOrdenCompraServicio servicioOrdenServicio;
    @Inject
    private IServicioTipoMoneda servicioTipoMoneda;
    @Inject
    private IServicioOrdenPedido servicioOrdenPedido;
    @Inject
    private IServicioCategoriaArticulo servicioCategoriaArticulo;
    /*@Inject
     private IServicioProveedorServicio servicioProveedorServicio;*/
    @Inject
    private IServicioArticulo servicioArticulo;
    @Inject
    private IServicioComposicionArticulo servicioComposicionArticulo;
    @Inject
    private IServicioDetalleOrdenCompraServicio servicioDetalleOrdenServicio;
    @Inject
    private IServicioContacto servicioContacto;
    @Inject
    private IServicioSede servicioSede;
    @Inject
    private IServicioCorrelativoDocumento servicioCorrelativo;
    @Inject
    private IServicioTipoDocumento servicioTipoDocumento;
    @Inject
    private IServicioProveedor servicioProveedor;
    @Inject
    private BKDetalleOrdenCompraServicio bkDetalleOrdenCompraServicio;
    @Inject
    private IServicioIgv servicioIgv;
    @Inject
    private IServicioServicio servicioServicio;
    @Inject
    private IServicioTipoFormaPago servicioFormaPago;
    @Inject
    private IServicioParametro servicioParametro;
    @Inject
    private MBCompBuscarDireccion mbSede;
    @Inject
    private MBComponenteFindProveedor mbComponenteFindProveedor;
    @Autowired
    BKSession session;

    public MBOrdenServicio() {
    }

    public void buscarArticulosCompPorTela(OrdenPedido ordenPedido) {

        try {
            this.bkOrdenServicio.setListaArticuloComp(new ArrayList<Articulo>());
            String modelo = "";
            for (DetallePedidoOp detalleOP : ordenPedido.getDetallePedidoOpCollection()) {
                if (detalleOP.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {

                    ComposicionArticulo composicion = new ComposicionArticulo();
                    composicion.setIdArticulo(detalleOP.getIdArticulo());
                    this.bkOrdenServicio.getListaArticuloComp().add(detalleOP.getIdArticulo());
                    Collection<ComposicionArticulo> listaComposicion = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion);

                    Iterator itr = listaComposicion.iterator();
                    //if (!modelo.equalsIgnoreCase(detalleOP.getIdArticulo().getModelo())) {

                    while (itr.hasNext()) {
                        ComposicionArticulo comp = (ComposicionArticulo) itr.next();

                        if (this.bkOrdenServicio.getListaArticuloComp().contains(comp.getIdArticuloComp())) {
                        } else {
                            if (comp.getIdArticuloComp().getIdCategoriaArticulo().getTipoMaterial() == 'C') {
                                this.bkOrdenServicio.getListaArticuloComp().add(comp.getIdArticuloComp());

                                ComposicionArticulo composicion1 = new ComposicionArticulo();
                                composicion1.setIdArticulo(comp.getIdArticuloComp());
                                Collection<ComposicionArticulo> listaComposicionAdd = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion1);
                                itr.remove();
                                if (listaComposicionAdd.size() > 0) {
                                    listaComposicion.addAll(listaComposicionAdd);
                                }
                                itr = listaComposicion.iterator();
                            }

                        }


                    }
                    modelo = detalleOP.getIdArticulo().getModelo();
                    //}

                }
            }

            /*for (Articulo a : this.bkOrdenServicio.getListaArticuloComp()) {
             System.out.println("nombre articulo: " + a.getNombreComercial());
             }*/
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void buscarArticulosCompPorPrenda(OrdenPedido ordenPedido) {

        try {
            this.bkOrdenServicio.setListaArticuloComp(new ArrayList<Articulo>());
            String modelo = "";
            for (DetallePedidoOp detalleOP : ordenPedido.getDetallePedidoOpCollection()) {
                if (detalleOP.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {
                    ComposicionArticulo composicion = new ComposicionArticulo();
                    composicion.setIdArticulo(detalleOP.getIdArticulo());
                    this.bkOrdenServicio.getListaArticuloComp().add(detalleOP.getIdArticulo());
                    Collection<ComposicionArticulo> listaComposicion = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion);

                    Iterator itr = listaComposicion.iterator();
                    if (!modelo.equalsIgnoreCase(detalleOP.getIdArticulo().getModelo())) {
                        while (itr.hasNext()) {
                            ComposicionArticulo comp = (ComposicionArticulo) itr.next();

                            if (this.bkOrdenServicio.getListaArticuloComp().contains(comp.getIdArticuloComp())) {
                            } else {
                                if (comp.getIdArticuloComp().getIdCategoriaArticulo().getTipoMaterial() == 'C') {
                                    this.bkOrdenServicio.getListaArticuloComp().add(comp.getIdArticuloComp());
                                }

                            }
                            if (!comp.getIdArticuloComp().getIdCategoriaArticulo().getNombre().contains("TELA")) {
                                ComposicionArticulo composicion1 = new ComposicionArticulo();
                                composicion1.setIdArticulo(comp.getIdArticuloComp());
                                Collection<ComposicionArticulo> listaComposicionAdd = servicioComposicionArticulo.buscarComposicionPorArticulo(composicion1);
                                itr.remove();
                                if (listaComposicionAdd.size() > 0) {
                                    listaComposicion.addAll(listaComposicionAdd);
                                }
                                itr = listaComposicion.iterator();
                            }
                        }
                        modelo = detalleOP.getIdArticulo().getModelo();
                    }
                }
            }

            /*for (Articulo a : this.bkOrdenServicio.getListaArticuloComp()) {
             System.out.println("nombre articulo: " + a.getNombreComercial());

             }*/
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void buscarListaOrdenServicios() {

        OrdenCompraServicio objOrdenServicio = this.bkOrdenServicio.getOrdenCSBusqueda();
        objOrdenServicio.setIdOrdenPedido(bkOrdenServicio.getOrdenPedidoBusqueda());

        /*if (objOrdenServicio.getIdOrdenPedido() == null) {
         objOrdenServicio.setIdOrdenPedido(new OrdenPedido());
         }*/
        //objOrdenServicio.getIdOrdenPedido().setIdEmpresa(session.getEmpresa());
        objOrdenServicio.setTipo(bkOrdenServicio.getTipoOrden());

        try {
            bkOrdenServicio.setListaOrdenCompraServiciosActivas(
                    servicioOrdenServicio.buscarOrdenCompraServiciosPorFiltro(objOrdenServicio, bkOrdenServicio.getFechaInicio(), bkOrdenServicio.getFechaFinal()));
            for (OrdenCompraServicio orden : bkOrdenServicio.getListaOrdenCompraServiciosActivas()) {
                System.out.println(orden.getIdOrdenPedido());
            }

        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }

    }

    public void buscarListaOrdenServiciosAntiguas() {
        OrdenCompraServicio objOrdenServicio = this.bkOrdenServicio.getOrdenCSBusqueda();
        objOrdenServicio.setEstadoOrden("" + OrdenCompraServicio.ESTADO_ORDEN_SC.BORRADOR.getValor());
        objOrdenServicio.setIdOrdenPedido(bkOrdenServicio.getOrdenPedidoBusqueda());
        objOrdenServicio.setTipo(bkOrdenServicio.getTipoOrden());
        String[] listaEsdado = {"" + OrdenCompraServicio.ESTADO_ORDEN_SC.ANULADO.getValor(),
            "" + OrdenCompraServicio.ESTADO_ORDEN_SC.BORRADOR.getValor()};
        try {
            bkOrdenServicio.setListaOrdenCompraServiciosActivas(servicioOrdenServicio.listarOrdenCSConCodigoPorOP(objOrdenServicio, listaEsdado));
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al cargar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public String mostrarMantenimiento() {
        try {
            bkOrdenServicio.setTipoOrden('S');
            bkOrdenServicio.setOrdenPedidoBusqueda(new OrdenPedido(-1));
            bkOrdenServicio.setOrdenCSBusqueda(new OrdenCompraServicio());
            bkOrdenServicio.getOrdenCSBusqueda().setEstadoOrden("");
            bkOrdenServicio.getOrdenCSBusqueda().setDescripcion("");
            bkOrdenServicio.getOrdenCSBusqueda().setServicio("");
            bkOrdenServicio.getOrdenCSBusqueda().setCodigo("");
            bkOrdenServicio.getOrdenCSBusqueda().setIdEmpresa(session.getEmpresa());
            bkOrdenServicio.setOrdenServicioFormulario(new OrdenCompraServicio());
            bkOrdenServicio.setListaOrdenCompraServiciosActivas(null);
            bkOrdenServicio.getOrdenCSBusqueda().setIdProveedor(new Proveedor());
            bkOrdenServicio.getOrdenCSBusqueda().getIdProveedor().setRazonSocial("");
            OrdenPedido ordenp = new OrdenPedido();
            ordenp.setIdEmpresa(session.getEmpresa());
            bkOrdenServicio.setListaOrdenesPedido(servicioOrdenPedido.listarOrdenesPedidoActivosPorEmpresa(ordenp));
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al actualizar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }

        return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_SERVICIO;
    }

    public String nuevo() {

        this.bkOrdenServicio.setComando(new ComandoGuardar(this));
        bkPartidaDespacho.setListaDetallePartidas(new ArrayList<PartidaDespacho>());
        bkPartidaDespacho.setListaDetallePartidasGeneral(new ArrayList<PartidaDespacho>());
        mbSede.addObserver(this);
        mbComponenteFindProveedor.clearObserver();
        mbComponenteFindProveedor.addObserver(this);
        cargarCombo();
        OrdenPedido ordenp = new OrdenPedido();
        ordenp.setEstadoPedido("E");
        ordenp.setIdEmpresa(session.getEmpresa());

        bkOrdenServicio.inicializarBean();
        bkOrdenServicio.getOrdenServicioFormulario().setIdOrdenPedido(new OrdenPedido());
        bkOrdenServicio.getOrdenServicioFormulario().setIdTipoMoneda(new TipoMoneda());
        bkOrdenServicio.getOrdenServicioFormulario().getIdTipoMoneda().setId(0);
        bkOrdenServicio.getOrdenServicioFormulario().setIdEmpresa(session.getEmpresa());
        bkOrdenServicio.getOrdenServicioFormulario().setCodigo("");
        bkOrdenServicio.getOrdenServicioFormulario().setProductoPedido(null);
        bkOrdenServicio.getOrdenServicioFormulario().setCrearPartidas((short) 0);
        bkOrdenServicio.getOrdenServicioFormulario().setEsImportacion((short) 0);
        try {
            bkOrdenServicio.setListaOrdenesPedido(servicioOrdenPedido.listarOrdenesPedidoPorEstado(ordenp));
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        return URLPaginacion.OrdenCompraServicio.URL_FORMULARIO_ORDEN_SERVICIO;
    }

    public String editar() {
        this.bkOrdenServicio.setComando(new ComandoActualizar(this));
        mbSede.addObserver(this);
        mbComponenteFindProveedor.clearObserver();
        mbComponenteFindProveedor.addObserver(this);
        bkOrdenServicio.setListaPartidaDespacho(new ArrayList<PartidaDespacho>());
        bkPartidaDespacho.setListaDetallePartidas(new ArrayList<PartidaDespacho>());
        bkPartidaDespacho.setListaDetallePartidasGeneral(new ArrayList<PartidaDespacho>());
        bkOrdenServicio.setOrdenCSAntigua(null);
        try {
            bkOrdenServicio.setOrdenServicioFormulario(servicioOrdenServicio.conseguirOrdenCompraServicioPorId(bkOrdenServicio.getOrdenServicioFormulario().getId()));
            OrdenCompraServicio orden = bkOrdenServicio.getOrdenServicioFormulario();

            cargarCombo();
            iniciarEdicion(orden);
            bkOrdenServicio.setEstadoOrdenCompraServicio(orden.getEstadoOrden());

        } catch (ServiceException e) {
            e.printStackTrace();
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }

        return URLPaginacion.OrdenCompraServicio.URL_FORMULARIO_ORDEN_SERVICIO;
    }

    public void iniciarEdicion(OrdenCompraServicio orden) {
        try {

            Sede sede = new Sede();
            sede.setIdProveedor(orden.getIdProveedor());
            sede.setSedeAdministradora(1);
            bkOrdenServicio.setListaContacto(servicioContacto.buscarContactosPorSede(servicioSede.buscarSedeAdministradora(sede)));
            bkOrdenServicio.setListaTemporalDetalleOrdenCompraServicio(new ArrayList<DetalleOrdenCompraServicio>());
            bkOrdenServicio.setListaDetalleOrdenCompraServicio(new ArrayList<DetalleOrdenCompraServicio>());
            inicializarDetallesOrdenCS(servicioDetalleOrdenServicio.listarDetallesPorOrden(orden));
            /*for (DetalleOrdenCompraServicio detalle1 : bkOrdenServicio.getListaDetalleOrdenCompraServicio()) {
             if (detalle1.getPartidaDespachoCollection() != null) {
             bkOrdenServicio.getListaPartidaDespacho().addAll(detalle1.getPartidaDespachoCollection());
             }

             }*/
            //buscarDetalles();
            buscarProductosDePedido();
            bkOrdenServicio.setServicioFormulario(servicioServicio.obtenerServicioPorNombre(orden.getServicio()));
            seleccionarServicio();

            bkOrdenServicio.setListaTipoPago(new ArrayList<String>());
            for (ParametroDetalle param : servicioParametro.listarTipoPago(orden.getFormaPago().getNombre())) {
                bkOrdenServicio.getListaTipoPago().add(param.getValCadena());
            }

            /*ProveedorServicio provServ = new ProveedorServicio();
             provServ.setServicio(bkOrdenServicio.getServicioFormulario());
             System.out.println("servicio2: "+provServ.getServicio());
             for (ProveedorServicio proSer : servicioProveedorServicio.listarProveedoresPorServicio(provServ)) {
             bkOrdenServicio.getListaProveedorS().add(proSer.getProveedor());
             }*/
            //buscarArticulosPorCategoria();
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public void inicializarDetallesOrdenCS(Collection<DetalleOrdenCompraServicio> lista) {


        for (DetalleOrdenCompraServicio detalle : lista) {
            DetalleOrdenCompraServicio detalleAgregar = new DetalleOrdenCompraServicio();
            detalleAgregar.setCantidad(detalle.getCantidad());
            detalleAgregar.setCantidadForm(detalle.getCantidadForm());
            detalleAgregar.setEstadoRegistro(ESTADO_REGISTRO.ACTIVO.getValor());
            detalleAgregar.setFecCreacion(detalle.getFecCreacion());
            detalleAgregar.setFecModificacion(detalle.getFecModificacion());
            detalleAgregar.setIdArticulo(detalle.getIdArticulo());
            detalleAgregar.setNombreArticulo(detalle.getIdArticulo().getNombreComercial());
            System.out.println(" unidad min: " + detalle.getIdTipoUnidadMinima().getId());
            detalleAgregar.setIdTipoUnidadMinima(detalle.getIdTipoUnidadMinima());
            detalleAgregar.setObservacion(detalle.getObservacion());
            detalleAgregar.setPrecio(detalle.getPrecio());
            detalleAgregar.setPrecioForm(detalle.getPrecioForm());
            detalleAgregar.setSubTotal(detalle.getSubTotal());
            detalleAgregar.setUnidadMedidaForm(detalle.getUnidadMedidaForm());
            detalleAgregar.setUsrCreacion(detalle.getUsrCreacion());
            detalleAgregar.setUsrModificacion(detalle.getUsrModificacion());
            detalleAgregar.setTotalRecibido(detalle.getTotalRecibido());
            if (bkOrdenServicio.getComando().getNombre().equalsIgnoreCase("Actualizar")) {
                detalleAgregar.setId(detalle.getId());
                detalleAgregar.setPartidaDespachoCollection(detalle.getPartidaDespachoCollection());
                System.out.println(" partidas:" + detalleAgregar.getPartidaDespachoCollection());
                detalleAgregar.setIdOrdenCompraServicio(detalle.getIdOrdenCompraServicio());
            }
            if (bkOrdenServicio.getOrdenCSAntigua() != null) {
                detalleAgregar.setPartidaDespachoCollection(new ArrayList<PartidaDespacho>());
                for (PartidaDespacho partida : detalle.getPartidaDespachoCollection()) {
                    if (partida.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {
                        PartidaDespacho partidaAgregar = new PartidaDespacho();
                        partidaAgregar.setCantidad(partida.getCantidad());
                        partidaAgregar.setDetalle(partida.getDetalle());
                        partidaAgregar.setEstadoRegistro(ESTADO_REGISTRO.ACTIVO.getValor());
                        partidaAgregar.setFecCreacion(new Date());
                        partidaAgregar.setUsrCreacion(session.getUsuario().getUsuario());
                        partidaAgregar.setIdDetalleOrdenCompraServicio(detalleAgregar);
                        partidaAgregar.setNumeracion(partida.getNumeracion());
                        detalleAgregar.getPartidaDespachoCollection().add(partidaAgregar);
                    }
                }
            }

            bkOrdenServicio.getListaDetalleOrdenCompraServicio().add(detalleAgregar);
            bkOrdenServicio.getListaTemporalDetalleOrdenCompraServicio().add(detalleAgregar);
        }


    }

    public String ver() {
        editar();
        return URLPaginacion.OrdenCompraServicio.URL_VER_ORDEN_SERVICIO;
    }

    public String guardar() {
        OrdenCompraServicio ordenCS = bkOrdenServicio.getOrdenServicioFormulario();

        ordenCS.setFecCreacion(new Date());
        ordenCS.setUsrCreacion(session.getUsuario().getUsuario());
        ordenCS.setTipo(bkOrdenServicio.getTipoOrden());
        ordenCS.setEstadoOrden(bkOrdenServicio.getEstadoOrdenCompraServicio());

        try {
            ordenCS.setId(null);
            ordenCS.setUsrModificacion(null);
            ordenCS.setFecModificacion(null);
            if (bkOrdenServicio.getOrdenCSAntigua() != null && bkOrdenServicio.getOrdenServicioFormulario().getCodigo().equalsIgnoreCase(bkOrdenServicio.getOrdenCSAntigua().getCodigo())) {
                bkOrdenServicio.getOrdenServicioFormulario().setCodigo("");
            }
            bkOrdenServicio.getOrdenServicioFormulario().setFormaPago(
                    servicioFormaPago.conseguirTipoFormaPagoPorNombre(bkOrdenServicio.getOrdenServicioFormulario().getFormaPago().getNombre()));

            if (bkOrdenServicio.getListaDetalleOrdenCompraServicio() != null) {
                for (DetalleOrdenCompraServicio detalle : bkOrdenServicio.getListaDetalleOrdenCompraServicio()) {
                    detalle.setIdOrdenCompraServicio(ordenCS);
                    //servicioDetalleOrdenServicio.guardarDetalleOrdenCompraServicio(detalle);
                }
            }
            ordenCS.setDetalleOrdenCompraServicioCollection(new ArrayList<DetalleOrdenCompraServicio>());
            ordenCS.getDetalleOrdenCompraServicioCollection().addAll(bkOrdenServicio.getListaDetalleOrdenCompraServicio());
            servicioOrdenServicio.guardarOrdenCompraServicio(ordenCS);

            mostrarMensaje("Se guardo la Orden de Servicio satisfactoriamente.");
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al guardar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        buscarListaOrdenServicios();
        /*if (ordenCS.getEstadoOrden().equalsIgnoreCase("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor())) {
         return ver();
         } else {
         return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_SERVICIO;
         }*/
        return ver();
        //return mostrarMantenimiento();
    }

    public String actualizar() {
        OrdenCompraServicio ordenCS = bkOrdenServicio.getOrdenServicioFormulario();

        ordenCS.setUsrModificacion(session.getUsuario().getUsuario());
        ordenCS.setFecModificacion(new Date());
        ordenCS.setTipo(bkOrdenServicio.getTipoOrden());
        ordenCS.setEstadoOrden(bkOrdenServicio.getEstadoOrdenCompraServicio());

        try {
            bkOrdenServicio.getOrdenServicioFormulario().setFormaPago(
                    servicioFormaPago.conseguirTipoFormaPagoPorNombre(bkOrdenServicio.getOrdenServicioFormulario().getFormaPago().getNombre()));

            if (!bkOrdenServicio.getListaTemporalDetalleOrdenCompraServicio().isEmpty()) {

                for (DetalleOrdenCompraServicio detalle : bkOrdenServicio.getListaTemporalDetalleOrdenCompraServicio()) {
                    if (detalle.getId() == null) {
                        detalle.setIdOrdenCompraServicio(ordenCS);
                        //servicioDetalleOrdenServicio.guardarDetalleOrdenCompraServicio(detalle);

                    }/* else {
                     detalle.setFecModificacion(new Date());
                     //servicioDetalleOrdenServicio.actualizarDetalleOrdenCompraServicio(detalle);

                     }*/
                }
            }
            ordenCS.setDetalleOrdenCompraServicioCollection(new ArrayList<DetalleOrdenCompraServicio>());
            ordenCS.getDetalleOrdenCompraServicioCollection().addAll(bkOrdenServicio.getListaTemporalDetalleOrdenCompraServicio());
            servicioOrdenServicio.actualizarOrdenCompraServicio(ordenCS);

            mostrarMensaje("Se actualizo los datos de la Orden de Servicio satisfactoriamente.");
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al actualizar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        buscarListaOrdenServicios();

        /*if (ordenCS.getEstadoOrden().equalsIgnoreCase("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor())) {
         return ver();
         } else {
         return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_SERVICIO;
         }*/

        return ver();
        //return mostrarMantenimiento();
    }

    public void eliminar(ActionEvent actionEvent) {
        OrdenCompraServicio ordenCS = bkOrdenServicio.getOrdenCompraServicioSeleccionado();
        ordenCS.setEstadoRegistro(ESTADO_REGISTRO.INACTIVO.getValor());
        ordenCS.setUsrModificacion(session.getUsuario().getUsuario());
        ordenCS.setFecModificacion(new Date());
        try {
            servicioOrdenServicio.actualizarOrdenCompraServicio(ordenCS);
            //bkOrdenCompra.setListaOrdenCompraServiciosActivas(servicioOrdenCompra.listarOrdenCompraServiciosPorFiltro(bkOrdenCompra.getIdOrdenPedidoBusqueda()));
            buscarListaOrdenServicios();
            mostrarMensaje("Se elimino la Orden de Servicio satisfactoriamente");
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al eliminar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
    }

    public String aceptar() {
        try {
            servicioOrdenServicio.actualizarOrdenCompraServicio(bkOrdenServicio.getOrdenServicioFormulario());
            bkOrdenServicio.setOrdenServicioFormulario(servicioOrdenServicio.conseguirOrdenCompraServicioPorId(1));
        } catch (ServiceException e) {
            mostrarError("Ocurrieron algunos problemas al actualizar la informacion. Vuelva a intentar.");
            logger.error(e.getMessage(), e);
        }
        return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_SERVICIO;
    }

    private void cargarCombo() {
        bkDetalleOrdenCompraServicio.setListaArticulo(null);
        bkDetalleOrdenCompraServicio.setIgvFormulario(null);
        //bkOrdenServicio.setListaProveedorS(new ArrayList<Proveedor>());
        try {
            bkDetalleOrdenCompraServicio.setIgvFormulario(servicioIgv.ConseguirIgvVigente());
            bkOrdenServicio.setListaTipoMoneda(servicioTipoMoneda.listarTipoMonedasActivos());
            bkOrdenServicio.setListaServicio(servicioServicio.listarServiciosActivos());
            bkOrdenServicio.setListaFormaPago(servicioFormaPago.obtenerTipoFormaPagoActivos());
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public Collection<OrdenPedido> buscarOrdenPedido(String ordenPedidoABuscar) {
        bkOrdenServicio.setEstaOrdenPedidoSeleccionado(false);
        Collection<OrdenPedido> listaOrdenesPedidoEncontrados = new ArrayList<OrdenPedido>();
        for (OrdenPedido ordenPedido : bkOrdenServicio.getListaOrdenesPedido()) {
            if (ordenPedido.getCodigoOrdenPedido().contains(ordenPedidoABuscar)) {
                listaOrdenesPedidoEncontrados.add(ordenPedido);
            }
        }
        return listaOrdenesPedidoEncontrados;
    }

    public List<String> buscarContacto(String contactoABuscar) {
        bkOrdenServicio.setEstaContactoSeleccionado(false);
        List<String> listaContactosEncontrados = new ArrayList<String>();
        for (Contacto contacto : bkOrdenServicio.getListaContacto()) {
            if (contacto.getNombre().contains(contactoABuscar)) {
                listaContactosEncontrados.add(contacto.getNombre());
            }
        }
        return listaContactosEncontrados;
    }

    public Collection<Servicio> buscarServicio(String servicioABuscar) {
        Collection<Servicio> listaServicioEncontrados = new ArrayList<Servicio>();
        for (Servicio servicio : bkOrdenServicio.getListaServicio()) {
            if (servicio.getNombre().contains(servicioABuscar)) {
                listaServicioEncontrados.add(servicio);
            }
        }
        return listaServicioEncontrados;
    }

    public Collection<Proveedor> buscarProveedor(String proveedorABuscar) {
        Collection<Proveedor> listaProveerdorEncontrados = new ArrayList<Proveedor>();
        for (Proveedor prov : bkOrdenServicio.getListaProveedorS()) {
            if (prov.getRazonSocial().contains(proveedorABuscar)) {
                listaProveerdorEncontrados.add(prov);
            }
        }
        return listaProveerdorEncontrados;
    }

    public void buscarProductosDePedido() {

        bkOrdenServicio.setListaArticuloComp(new ArrayList<Articulo>());
        if (bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido() != null && bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido().getId() != 0) {

            try {
                bkOrdenServicio.getOrdenServicioFormulario().setIdOrdenPedido(
                        servicioOrdenPedido.conseguirOrdenPedidoPorId(bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido().getId()));
            } catch (ServiceException e) {
                logger.error(e.getMessage(), e);
                mostrarError("Ocurrio un error al cargar la informacion.");
            }

            if (bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido().getTipoOp() == 'T') {
                buscarArticulosCompPorTela(bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido());
            } else {
                buscarArticulosCompPorPrenda(bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido());
            }
            buscarServicios();
            if (bkOrdenServicio.getComando().getNombre().equalsIgnoreCase("Guardar") && bkOrdenServicio.getOrdenServicioFormulario().getCodigo().isEmpty()) {
                seleccionarServicio();
            }
        } else {

            bkOrdenServicio.setServicioFormulario(null);
            try {

                bkOrdenServicio.setListaServicio(servicioServicio.listarServiciosActivos());
            } catch (ServiceException e) {
                logger.error(e.getMessage(), e);
                mostrarError("Ocurrio un error al cargar la informacion.");
            }
            //seleccionarSubCategoria();
        }


    }

    public void buscarDetalles() {
        try {
            OrdenPedido ordenP = servicioOrdenPedido.conseguirOrdenPedidoPorId(bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido().getId());
            bkOrdenServicio.setListaDetallesPP(new ArrayList<String>());
            String nombreP = bkOrdenServicio.getOrdenServicioFormulario().getProductoPedido();
            for (DetallePedidoOp detalle : ordenP.getDetallePedidoOpCollection()) {
                if (nombreP.equals(detalle.getNombreProducto())) {
                    bkOrdenServicio.setArticuloCompuesto(detalle.getIdArticulo());
                    bkOrdenServicio.getListaDetallesPP().add(detalle.getDetalle());
                }
            }
            if (bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido().getTipoOp() == 'T') {
                buscarArticulosCompPorTela(bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido());
            } else {
                buscarArticulosCompPorPrenda(bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido());
            }
            buscarServicios();
            if (bkOrdenServicio.getComando().getNombre().equalsIgnoreCase("Guardar")) {
                seleccionarServicio();
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void buscarServicios() {
        bkOrdenServicio.setListaServicio(new ArrayList<Servicio>());
        List<CategoriaArticulo> listaCategorias = new ArrayList<CategoriaArticulo>();
        try {
            for (Articulo articulo : this.bkOrdenServicio.getListaArticuloComp()) {
                articulo = servicioArticulo.conseguirArticuloPorId(articulo.getId());
                boolean band = true;
                for (CategoriaArticulo categoria : listaCategorias) {
                    if (categoria == articulo.getIdCategoriaArticulo()) {
                        band = false;
                        break;
                    }
                }

                if (band) {
                    Collection<Servicio> listaServicio = new ArrayList<Servicio>();
                    if (!articulo.getIdCategoriaArticulo().getServicioCollection().isEmpty()) {
                        listaServicio = articulo.getIdCategoriaArticulo().getServicioCollection();
                    } else if (!articulo.getIdCategoriaArticulo().getIdCategoriaArticulo().getServicioCollection().isEmpty()) {
                        listaServicio = articulo.getIdCategoriaArticulo().getIdCategoriaArticulo().getServicioCollection();
                    }

                    for (Servicio serv : listaServicio) {
                        if (bkOrdenServicio.getListaServicio().contains(serv)) {
                            System.out.println("ya existe");
                        } else {
                            bkOrdenServicio.getListaServicio().add(serv);
                        }
                    }
                }


            }

            bkOrdenServicio.setServicioFormulario(null);
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void seleccionarServicio() {
        bkOrdenServicio.setListaProveedorS(new ArrayList<Proveedor>());
        try {
            if (bkOrdenServicio.getServicioFormulario() != null) {

                Servicio serv = bkOrdenServicio.getServicioFormulario();
                /*ProveedorServicio provServ = new ProveedorServicio();
                 provServ.setServicio(serv);

                 for (ProveedorServicio proSer : servicioProveedorServicio.listarProveedoresPorServicio(provServ)) {
                 bkOrdenServicio.getListaProveedorS().add(proSer.getProveedor());
                 }*/
                System.out.println(bkOrdenServicio.getListaProveedorS());
                bkOrdenServicio.getOrdenServicioFormulario().setServicio(serv.getNombre());
                bkOrdenServicio.getOrdenServicioFormulario().setIdCategoriaArticulo(serv.getIdCategoriaArticulo());
                buscarArticulosPorCategoria();
            } else {
                bkOrdenServicio.getOrdenServicioFormulario().setServicio(null);
                bkOrdenServicio.getOrdenServicioFormulario().setIdCategoriaArticulo(null);
                //bkOrdenServicio.getOrdenServicioFormulario().setIdProveedor(null);
                elegirProveedor();
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void buscarArticulosPorCategoria() {
        bkOrdenServicio.setListaArticuloCat(new ArrayList<Articulo>());
        List<Integer> ids = new ArrayList<Integer>();
        try {
            for (Articulo articulo : bkOrdenServicio.getListaArticuloComp()) {
                CategoriaArticulo categoria = servicioCategoriaArticulo.conseguirCategoriaArticuloPorId(articulo.getIdCategoriaArticulo().getId());
                if (bkOrdenServicio.getOrdenServicioFormulario().getIdCategoriaArticulo() == categoria && !ids.contains(articulo.getId())) {
                    bkOrdenServicio.getListaArticuloCat().add(articulo);
                    ids.add(articulo.getId());
                } else if (bkOrdenServicio.getOrdenServicioFormulario().getIdCategoriaArticulo() == categoria.getIdCategoriaArticulo() && !ids.contains(articulo.getId())) {
                    bkOrdenServicio.getListaArticuloCat().add(articulo);
                    ids.add(articulo.getId());
                }

            }
            if (bkOrdenServicio.getListaArticuloCat().isEmpty()) {
                Articulo articuloBusqueda = new Articulo();
                articuloBusqueda.setIdCategoriaArticulo(bkOrdenServicio.getOrdenServicioFormulario().getIdCategoriaArticulo());
                bkOrdenServicio.getListaArticuloCat().addAll(servicioArticulo.listarArticulosPorCategoria(articuloBusqueda));
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    public void elegirProveedor() {

        try {
            if (bkOrdenServicio.getOrdenServicioFormulario().getIdProveedor() != null) {

                bkOrdenServicio.getOrdenServicioFormulario().setDireccion(bkOrdenServicio.getOrdenServicioFormulario().getIdProveedor().getDireccionLegal());
                bkOrdenServicio.getOrdenServicioFormulario().setIdTipoMoneda(bkOrdenServicio.getOrdenServicioFormulario().getIdProveedor().getIdTipoMoneda());

                Sede sede = new Sede();
                sede.setIdProveedor(bkOrdenServicio.getOrdenServicioFormulario().getIdProveedor());
                sede.setSedeAdministradora(1);

                bkOrdenServicio.setListaContacto(servicioContacto.buscarContactosPorSede(servicioSede.buscarSedeAdministradora(sede)));
                bkOrdenServicio.getOrdenServicioFormulario().setIdProveedor(bkOrdenServicio.getOrdenServicioFormulario().getIdProveedor());

            } else {

                bkOrdenServicio.getOrdenServicioFormulario().setIdProveedor(null);
                bkOrdenServicio.getOrdenServicioFormulario().setDireccion(null);
                bkOrdenServicio.setListaContacto(null);

            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
    }

    public void seleccionarContacto() {
        try {
            if (bkOrdenServicio.getOrdenServicioFormulario().getContacto() != null) {
                for (Contacto contacto : bkOrdenServicio.getListaContacto()) {
                    if (contacto.getNombre().equalsIgnoreCase(bkOrdenServicio.getOrdenServicioFormulario().getContacto())) {
                        bkOrdenServicio.getOrdenServicioFormulario().setTelefono(contacto.getTelefono() + "/" + contacto.getMovil());
                    }
                }

            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    public void marcarInicio(DateSelectEvent event) {
        bkOrdenServicio.getOrdenServicioFormulario().setFechaEmision(event.getDate());
        if (bkOrdenServicio.getOrdenServicioFormulario().getPlazoEntrega() != null) {
            bkOrdenServicio.getOrdenServicioFormulario().setDiasPlazo(UtilitarioFecha.restarFechas(bkOrdenServicio.getOrdenServicioFormulario().getPlazoEntrega(),
                    bkOrdenServicio.getOrdenServicioFormulario().getFechaEmision()));
        }
    }

    public void marcarFin(DateSelectEvent event) {

        bkOrdenServicio.getOrdenServicioFormulario().setPlazoEntrega(event.getDate());
        bkOrdenServicio.getOrdenServicioFormulario().setDiasPlazo(UtilitarioFecha.restarFechas(bkOrdenServicio.getOrdenServicioFormulario().getPlazoEntrega(),
                bkOrdenServicio.getOrdenServicioFormulario().getFechaEmision()));
    }

    public void elegirMoneda() {
        try {
            bkOrdenServicio.getOrdenServicioFormulario().setIdTipoMoneda(
                    servicioTipoMoneda.conseguirTipoMonedaPorId(bkOrdenServicio.getOrdenServicioFormulario().getIdTipoMoneda().getId()));
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    public void elegirFormaPago() {
        try {
            if (bkOrdenServicio.getOrdenServicioFormulario().getFormaPago().getNombre() != null) {
                bkOrdenServicio.setListaTipoPago(new ArrayList<String>());
                for (ParametroDetalle param : servicioParametro.listarTipoPago(bkOrdenServicio.getOrdenServicioFormulario().getFormaPago().getNombre())) {
                    bkOrdenServicio.getListaTipoPago().add(param.getValCadena());
                }
                bkOrdenServicio.getOrdenServicioFormulario().setDiasPago(null);
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    @Override
    public String retroceder() {

        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public String cancelar() {
        buscarListaOrdenServicios();
        return URLPaginacion.OrdenCompraServicio.URL_LISTA_ORDEN_SERVICIO;
        //return mostrarMantenimiento();
    }

    /**
     * ******************************************* Busqueda de Antiguo
     * ***************************************************
     */
    public void inicializarBusquedaAntigua(ActionEvent actionEvent) {

        bkOrdenServicio.setOrdenPedidoBusqueda(new OrdenPedido(0));
        bkOrdenServicio.setListaOrdenCompraServiciosActivas(null);
        bkOrdenServicio.setOrdenCSAntigua(null);
        bkOrdenServicio.setIdOrdenCompraServicioAntigua(null);
        buscarListaOrdenServiciosAntiguas();
    }

    public void buscarOrdenAntigua() {
        try {
            if (bkOrdenServicio.getIdOrdenCompraServicioAntigua() != 0) {
                bkOrdenServicio.setOrdenCSAntigua(servicioOrdenServicio.conseguirOrdenCompraServicioPorId(bkOrdenServicio.getIdOrdenCompraServicioAntigua()));
            } else {
                bkOrdenServicio.setOrdenCSAntigua(null);
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }

    }

    public void aplicarDatosAntiguos(ActionEvent actionEvent) {
        OrdenCompraServicio ordenS = null;
        try {
            ordenS = servicioOrdenServicio.conseguirOrdenCompraServicioPorId(bkOrdenServicio.getOrdenCSAntigua().getId());
            ordenS.setProductoPedido(null);

            bkOrdenServicio.setOrdenServicioFormulario(ordenS);
            //bkOrdenServicio.getOrdenServicioFormulario().setCodigo("");
            bkOrdenServicio.setListaPartidaDespacho(new ArrayList<PartidaDespacho>());
            bkPartidaDespacho.setListaDetallePartidas(new ArrayList<PartidaDespacho>());
            bkPartidaDespacho.setListaDetallePartidasGeneral(new ArrayList<PartidaDespacho>());

            cargarCombo();
            iniciarEdicion(ordenS);
            //iniciarEdicion(bkOrdenServicio.getOrdenServicioFormulario());
            if (bkOrdenServicio.getOrdenServicioFormulario().getIdOrdenPedido() == null) {
                bkOrdenServicio.getOrdenServicioFormulario().setIdOrdenPedido(new OrdenPedido());
            }
        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
        //OrdenCompraServicio orden = bkOrdenServicio.getOrdenServicioFormulario();
    }

    @Override
    public void actualizarObservador(Object object) {
        if (object instanceof Map) {
            Map<String, Object> datos = (Map<String, Object>) object;
            Sede sede = (Sede) datos.get("sede");

            bkOrdenServicio.getOrdenServicioFormulario().setLugarEntrega(sede.getDireccion());
        }
        if (object instanceof Proveedor) {
            try {
                Proveedor proveedor = servicioProveedor.conseguirProveedorPorId(((Proveedor) object).getId());
                bkOrdenServicio.getOrdenServicioFormulario().setIdProveedor(proveedor);
                elegirProveedor();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public String emitirOrdenAntiguo() {

        CorrelativoDocumento correlativo = new CorrelativoDocumento();
        correlativo.setAnio(UtilitarioFecha.obtenerAnioActual());

        TipoDocumento tipoDocumento = new TipoDocumento();
        tipoDocumento.setNombre(Constantes.TipoDocumento.TIPO_DOC_ORDEN_SERVICIO);

        String format = "%1$05d";

        bkOrdenServicio.setEstadoOrdenCompraServicio("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor());
        Integer numero = 0;
        try {
            correlativo.setIdTipoDocumento(servicioTipoDocumento.obtenerTipoDocumentoPorNombre(tipoDocumento));
            correlativo.setIdsede(session.getSede());
            CorrelativoDocumento correlativoEncontrado = servicioCorrelativo.obtenerCorrelativoDocumentoPorAnio(correlativo);
            if (correlativoEncontrado == null) {

                correlativo.setUsrCreacion(session.getUsuario().getUsuario());
                correlativo.setFecCreacion(new Date());
                correlativo.setNumero("00002");
                servicioCorrelativo.guardarCorrelativoDocumento(correlativo);
                bkOrdenServicio.getOrdenServicioFormulario().setCodigo("OS-00001-" + correlativo.getAnio());

            } else {

                correlativo = correlativoEncontrado;
                numero = Integer.parseInt(correlativo.getNumero());
                bkOrdenServicio.getOrdenServicioFormulario().setCodigo("OS-" + String.format(format, numero) + "-" + correlativo.getAnio());
                numero++;
                correlativo.setNumero(String.format(format, numero));
                correlativo.setUsrModificacion(session.getUsuario().getUsuario());
                correlativo.setFecModificacion(new Date());
                servicioCorrelativo.actualizarCorrelativoDocumento(correlativo);

            }

        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
        mostrarMensaje("Su Orden de Servicio ha sido emitida");
        bkOrdenServicio.getOrdenServicioFormulario().setUsrEmision(session.getUsuario().getNombres() + " " + session.getUsuario().getApellidos());
        if (bkOrdenServicio.getComando().getNombre().equalsIgnoreCase("Guardar")) {
            return guardar();
        } else {
            return actualizar();
        }

    }

    public String emitirOrden() {

        String format = "%1$03d";

        bkOrdenServicio.setEstadoOrdenCompraServicio("" + OrdenCompraServicio.ESTADO_ORDEN_SC.ABIERTO.getValor());
        Integer numero = 0;
        try {
            numero = servicioOrdenServicio.buscarCantidadOS(bkOrdenServicio.getOrdenServicioFormulario());
            if (numero == 0) {
                bkOrdenServicio.getOrdenServicioFormulario().setCodigo("OS-"
                        + bkOrdenServicio.getServicioFormulario().getCodigo() + "001-"
                        + UtilitarioFecha.obtenerAnio(bkOrdenServicio.getOrdenServicioFormulario().getFechaEmision()));

            } else {
                numero++;
                bkOrdenServicio.getOrdenServicioFormulario().setCodigo("OS-"
                        + bkOrdenServicio.getServicioFormulario().getCodigo() + String.format(format, numero)
                        + "-" + UtilitarioFecha.obtenerAnio(bkOrdenServicio.getOrdenServicioFormulario().getFechaEmision()));

            }

        } catch (ServiceException e) {
            logger.error(e.getMessage(), e);
            mostrarError("Ocurrio un error al cargar la informacion.");
        }
        mostrarMensaje("Su Orden de Servicio ha sido emitida");
        bkOrdenServicio.getOrdenServicioFormulario().setUsrEmision(session.getUsuario().getNombres() + " " + session.getUsuario().getApellidos());
        if (bkOrdenServicio.getComando().getNombre().equalsIgnoreCase("Guardar")) {
            return guardar();
        } else {
            return actualizar();
        }

    }

    public void reportePartida() throws IOException, ServiceException {
        String imagen = serviceProperties.getProperty("path.server.logo") + session.getEmpresa().getLogo();

        HSSFWorkbook wb = new HSSFWorkbook();

        HSSFSheet sheet = wb.createSheet("Partidas");
        File pic = new File(imagen);

        HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
        HSSFClientAnchor anchor;
        anchor = new HSSFClientAnchor(500, 100, 600, 200, (short) 0, 0, (short) 2, 2);
        anchor.setAnchorType(2);
        HSSFPicture picture = patriarch.createPicture(anchor, loadPicture(pic, wb));

        sheet.setAutobreaks(true);
        sheet.setDefaultColumnWidth(10);
        sheet.setAlternativeFormula(true);
        //sheet.setVerticallyCenter(true);
        sheet.setRowSumsBelow(true);

        HSSFCellStyle borderStyle = wb.createCellStyle();
        borderStyle.setBorderBottom(HSSFCellStyle.BORDER_THIN);
        borderStyle.setBorderLeft(HSSFCellStyle.BORDER_THIN);
        borderStyle.setBorderRight(HSSFCellStyle.BORDER_THIN);
        borderStyle.setBorderTop(HSSFCellStyle.BORDER_THIN);

        /**
         * ***** fuente para titulo ******************
         */
        HSSFFont titFont = wb.createFont();
        titFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
        titFont.setFontHeightInPoints(Short.valueOf("7"));

        HSSFCellStyle titStyle = wb.createCellStyle();
        titStyle.setFont(titFont);

        /**
         * ***** fuente para cabecera ******************
         */
        HSSFFont cabFont = wb.createFont();
        cabFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
        cabFont.setFontHeightInPoints(Short.valueOf("7"));

        HSSFCellStyle cabStyle = wb.createCellStyle();
        cabStyle.cloneStyleFrom(borderStyle);
        cabStyle.setFont(cabFont);

        /**
         * ***** fuente normal ******************
         */
        HSSFFont genFont = wb.createFont();
        genFont.setFontHeightInPoints(Short.valueOf("7"));


        HSSFCellStyle genStyle = wb.createCellStyle();
        genStyle.cloneStyleFrom(borderStyle);
        genStyle.setFont(genFont);
        genStyle.setWrapText(true);

        /**
         * ***** fuente para servicio ******************
         */
        HSSFFont osFont = wb.createFont();
        osFont.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
        osFont.setFontHeightInPoints(Short.valueOf("9"));

        HSSFCellStyle osStyle = wb.createCellStyle();
        osStyle.setFont(osFont);


        HSSFRow row = sheet.createRow(4);

        HSSFCell cell = row.createCell(2);
        cell.setCellStyle(osStyle);
        cell.setCellValue("ORDEN DE " + bkOrdenServicio.getOrdenServicioFormulario().getServicio() + ": " + bkOrdenServicio.getOrdenServicioFormulario().getCodigo());
        int rowCont = 6;

        for (DetalleOrdenCompraServicio detalle : bkOrdenServicio.getListaDetalleOrdenCompraServicio()) {
            BigDecimal cantidad = BigDecimal.ZERO;
            row = sheet.createRow(rowCont);

            cell = row.createCell(1);
            cell.setCellStyle(titStyle);
            cell.setCellValue(detalle.getIdArticulo().getNombreComercial());

            rowCont++;

            row = sheet.createRow(rowCont);

            cell = row.createCell(1);
            cell.setCellStyle(cabStyle);
            cell.setCellValue("Partida");

            cell = row.createCell(2);
            cell.setCellStyle(cabStyle);
            cell.setCellValue("Cantidad");
            rowCont++;
            for (PartidaDespacho partida : detalle.getPartidaDespachoCollection()) {
                if (partida.getEstadoRegistro() == ESTADO_REGISTRO.ACTIVO.getValor()) {
                    row = sheet.createRow(rowCont);
                    cell = row.createCell(1);

                    cell.setCellStyle(genStyle);
                    cell.setCellValue(partida.getDetalle());
                    cantidad = cantidad.add(partida.getCantidad());
                    cell = row.createCell(2);
                    cell.setCellStyle(genStyle);
                    cell.setCellValue(partida.getCantidad().doubleValue());
                    rowCont++;

                }

            }
            row = sheet.createRow(rowCont);

            cell = row.createCell(2);
            cell.setCellStyle(cabStyle);
            cell.setCellValue(cantidad.doubleValue());


            rowCont += 2;
        }


        FacesContext facesContext = FacesContext.getCurrentInstance();
        ExternalContext externalContext = facesContext.getExternalContext();
        externalContext.setResponseContentType("application/vnd.ms-excel");
        externalContext.setResponseHeader("Content-Disposition", "attachment; filename=\"Partidas.xls\"");

        wb.write(externalContext.getResponseOutputStream());
        facesContext.responseComplete();

    }

    //Metodo que permite insertar imagenes a el excel
    private static int loadPicture(File path, HSSFWorkbook wb) throws IOException {
        int pictureIndex;
        FileInputStream fis = null;
        ByteArrayOutputStream bos = null;
        try {
            // read in the image file
            fis = new FileInputStream(path);
            bos = new ByteArrayOutputStream();
            int c;
            // copy the image bytes into the ByteArrayOutputStream
            while ((c = fis.read()) != -1) {
                bos.write(c);
            }

            // add the image bytes to the workbook
            pictureIndex = wb.addPicture(bos.toByteArray(), HSSFWorkbook.PICTURE_TYPE_PNG);

        } finally {
            if (fis != null) {
                fis.close();
            }
            if (bos != null) {
                bos.close();
            }
        }
        return pictureIndex;
    }
}
